home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / bash_114.zip / bash-1.14.2 / bashline.c < prev    next >
C/C++ Source or Header  |  1994-08-03  |  46KB  |  1,758 lines
  1. /* bashline.c -- Bash's interface to the readline library. */
  2.  
  3. /* Copyright (C) 1987,1991 Free Software Foundation, Inc.
  4.  
  5.    This file is part of GNU Bash, the Bourne Again SHell.
  6.  
  7.    Bash is free software; you can redistribute it and/or modify it
  8.    under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 1, or (at your option)
  10.    any later version.
  11.  
  12.    Bash is distributed in the hope that it will be useful, but WITHOUT
  13.    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14.    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15.    License for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License
  18.    along with Bash; see the file COPYING.  If not, write to the Free
  19.    Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  20.  
  21. #include "bashtypes.h"
  22. #include "posixstat.h"
  23.  
  24. #include <stdio.h>
  25. #include "bashansi.h"
  26. #include <readline/readline.h>
  27. #include <readline/history.h>
  28. #include "shell.h"
  29. #include "builtins.h"
  30. #include "builtins/common.h"
  31. #include "bashhist.h"
  32. #include "execute_cmd.h"
  33.  
  34. #if defined (ALIAS)
  35. #  include "alias.h"
  36. #endif
  37.  
  38. #if defined (BRACE_EXPANSION)
  39. #  define BRACE_COMPLETION
  40. #endif /* BRACE_EXPANSION */
  41.  
  42. #if defined (BRACE_COMPLETION)
  43. extern void bash_brace_completion ();
  44. #endif /* BRACE_COMPLETION */
  45.  
  46. /* Functions bound to keys in Readline for Bash users. */
  47. static void shell_expand_line ();
  48. static void display_shell_version (), operate_and_get_next ();
  49. static void history_expand_line (), bash_ignore_filenames ();
  50.  
  51. /* Helper functions for Readline. */
  52. static int bash_directory_completion_hook ();
  53. static void filename_completion_ignore ();
  54. static void bash_push_line ();
  55.  
  56. static char **attempt_shell_completion ();
  57. static char *variable_completion_function ();
  58. static char *hostname_completion_function ();
  59. static char *command_word_completion_function ();
  60. static char *command_subst_completion_function ();
  61.  
  62. static void snarf_hosts_from_file (), add_host_name ();
  63. static void sort_hostname_list ();
  64.  
  65. #define DYNAMIC_HISTORY_COMPLETION
  66. #if defined (DYNAMIC_HISTORY_COMPLETION)
  67. static void dynamic_complete_history ();
  68. #endif /* DYNAMIC_HISTORY_COMPLETION */
  69.  
  70. /* Variables used here but defined in other files. */
  71. extern int posixly_correct, no_symbolic_links;
  72. extern int rl_explicit_arg;
  73. extern char *current_prompt_string, *ps1_prompt;
  74. extern STRING_INT_ALIST word_token_alist[];
  75. extern Function *rl_last_func;
  76. extern int rl_filename_completion_desired;
  77.  
  78. /* SPECIFIC_COMPLETION_FUNCTIONS specifies that we have individual
  79.    completion functions which indicate what type of completion should be
  80.    done (at or before point) that can be bound to key sequences with
  81.    the readline library. */
  82. #define SPECIFIC_COMPLETION_FUNCTIONS
  83.  
  84. #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
  85. static void
  86.   bash_specific_completion (),
  87.   bash_complete_filename (), bash_possible_filename_completions (),
  88.   bash_complete_filename_internal (),
  89.   bash_complete_username (), bash_possible_username_completions (),
  90.   bash_complete_username_internal (),
  91.   bash_complete_hostname (), bash_possible_hostname_completions (),
  92.   bash_complete_hostname_internal (),
  93.   bash_complete_variable (), bash_possible_variable_completions (),
  94.   bash_complete_variable_internal (),
  95.   bash_complete_command (), bash_possible_command_completions (),
  96.   bash_complete_command_internal ();
  97. #endif /* SPECIFIC_COMPLETION_FUNCTIONS */
  98.  
  99. /* Non-zero once initalize_readline () has been called. */
  100. int bash_readline_initialized = 0;
  101.  
  102. #if defined (VI_MODE)
  103. static void vi_edit_and_execute_command ();
  104. #endif
  105.  
  106. static Function *old_rl_startup_hook = (Function *) NULL;
  107.  
  108. /* Change the readline VI-mode keymaps into or out of Posix.2 compliance.
  109.    Called when the shell is put into or out of `posix' mode. */
  110. void
  111. posix_readline_initialize (on_or_off)
  112.      int on_or_off;
  113. {
  114. #if defined (VI_MODE)
  115.   if (on_or_off)
  116.     {
  117.       rl_bind_key_in_map (CTRL('I'), rl_insert, vi_insertion_keymap);
  118.       if (rl_vi_comment_begin)
  119.     free (rl_vi_comment_begin);
  120.       rl_vi_comment_begin = savestring ("#");
  121.     }
  122.   else
  123.     rl_bind_key_in_map (CTRL('I'), rl_complete, vi_insertion_keymap);
  124. #endif
  125. } 
  126.  
  127. /* Called once from parse.y if we are going to use readline. */
  128. void
  129. initialize_readline ()
  130. {
  131.   if (bash_readline_initialized)
  132.     return;
  133.  
  134.   rl_terminal_name = get_string_value ("TERM");
  135.   rl_instream = stdin;
  136.   rl_outstream = stderr;
  137.   rl_special_prefixes = "$@";
  138.  
  139.   /* Allow conditional parsing of the ~/.inputrc file. */
  140.   rl_readline_name = "Bash";
  141.  
  142.   /* Bind up our special shell functions. */
  143.   rl_add_defun ("shell-expand-line", (Function *)shell_expand_line, -1);
  144.   rl_bind_key_in_map
  145.     (CTRL('E'), (Function *)shell_expand_line, emacs_meta_keymap);
  146.  
  147.   /* Bind up our special shell functions. */
  148.   rl_add_defun ("history-expand-line", (Function *)history_expand_line, -1);
  149.   rl_bind_key_in_map ('^', (Function *)history_expand_line, emacs_meta_keymap);
  150.  
  151.   /* Backwards compatibility. */
  152.   rl_add_defun ("insert-last-argument", rl_yank_last_arg, -1);
  153.  
  154.   rl_add_defun
  155.     ("operate-and-get-next", (Function *)operate_and_get_next, CTRL('O'));
  156.  
  157.   rl_add_defun
  158.     ("display-shell-version", (Function *)display_shell_version, -1);
  159.  
  160.   rl_bind_key_in_map
  161.     (CTRL ('V'), (Function *)display_shell_version, emacs_ctlx_keymap);
  162.  
  163.   /* In Bash, the user can switch editing modes with "set -o [vi emacs]",
  164.      so it is not necessary to allow C-M-j for context switching.  Turn
  165.      off this occasionally confusing behaviour. */
  166.   rl_unbind_key_in_map (CTRL('J'), emacs_meta_keymap);
  167.   rl_unbind_key_in_map (CTRL('M'), emacs_meta_keymap);
  168.  
  169. #if defined (BRACE_COMPLETION)
  170.   rl_add_defun ("complete-into-braces", bash_brace_completion, -1);
  171.   rl_bind_key_in_map ('{', bash_brace_completion, emacs_meta_keymap);
  172. #endif /* BRACE_COMPLETION */
  173.  
  174. #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
  175.   rl_add_defun ("complete-filename", bash_complete_filename, -1);
  176.   rl_bind_key_in_map ('/', bash_complete_filename, emacs_meta_keymap);
  177.   rl_add_defun ("possible-filename-completions",
  178.         bash_possible_filename_completions, -1);
  179.   rl_bind_key_in_map ('/', bash_possible_filename_completions,
  180.               emacs_ctlx_keymap);
  181.  
  182.   rl_add_defun ("complete-username", bash_complete_username, -1);
  183.   rl_bind_key_in_map ('~', bash_complete_username, emacs_meta_keymap);
  184.   rl_add_defun ("possible-username-completions",
  185.         bash_possible_username_completions, -1);
  186.   rl_bind_key_in_map ('~', bash_possible_username_completions,
  187.               emacs_ctlx_keymap);
  188.  
  189.   rl_add_defun ("complete-hostname", bash_complete_hostname, -1);
  190.   rl_bind_key_in_map ('@', bash_complete_hostname, emacs_meta_keymap);
  191.   rl_add_defun ("possible-hostname-completions",
  192.         bash_possible_hostname_completions, -1);
  193.   rl_bind_key_in_map ('@', bash_possible_hostname_completions,
  194.               emacs_ctlx_keymap);
  195.  
  196.   rl_add_defun ("complete-variable", bash_complete_variable, -1);
  197.   rl_bind_key_in_map ('$', bash_complete_variable, emacs_meta_keymap);
  198.   rl_add_defun ("possible-variable-completions",
  199.         bash_possible_variable_completions, -1);
  200.   rl_bind_key_in_map ('$', bash_possible_variable_completions,
  201.               emacs_ctlx_keymap);
  202.  
  203.   rl_add_defun ("complete-command", bash_complete_command, -1);
  204.   rl_bind_key_in_map ('!', bash_complete_command, emacs_meta_keymap);
  205.   rl_add_defun ("possible-command-completions",
  206.         bash_possible_command_completions, -1);
  207.   rl_bind_key_in_map ('!', bash_possible_command_completions,
  208.               emacs_ctlx_keymap);
  209.  
  210. #endif /* SPECIFIC_COMPLETION_FUNCTIONS */
  211.  
  212. #if defined (DYNAMIC_HISTORY_COMPLETION)
  213.   rl_add_defun ("dynamic-complete-history", dynamic_complete_history, -1);
  214.   rl_bind_key_in_map (TAB, dynamic_complete_history, emacs_meta_keymap);
  215. #endif /* DYNAMIC_HISTORY_COMPLETION */
  216.  
  217.   /* Tell the completer that we want a crack first. */
  218.   rl_attempted_completion_function = (CPPFunction *)attempt_shell_completion;
  219.  
  220.   /* Tell the completer that we might want to follow symbolic links or
  221.      do other expansion on directory names. */
  222.   rl_directory_completion_hook = bash_directory_completion_hook;
  223.  
  224.   /* Tell the filename completer we want a chance to ignore some names. */
  225.   rl_ignore_some_completions_function = (Function *)filename_completion_ignore;
  226.  
  227. #if defined (VI_MODE)
  228.   rl_bind_key_in_map ('v', vi_edit_and_execute_command, vi_movement_keymap);
  229. #endif
  230.  
  231.   rl_completer_quote_characters = "'\"";
  232.   /* Need to modify this from the default; `$', `{', `\', and ``' are not
  233.      word break characters. */
  234.   rl_completer_word_break_characters = " \t\n\"'@><=;|&("; /**/
  235.  
  236.   if (posixly_correct)
  237.     posix_readline_initialize (1);
  238.  
  239.   bash_readline_initialized = 1;
  240. }
  241.  
  242. /* On Sun systems at least, rl_attempted_completion_function can end up
  243.    getting set to NULL, and rl_completion_entry_function set to do command
  244.    word completion if Bash is interrupted while trying to complete a command
  245.    word.  This just resets all the completion functions to the right thing.
  246.    It's called from throw_to_top_level(). */
  247. void
  248. bashline_reinitialize ()
  249. {
  250.   tilde_initialize ();
  251.   rl_attempted_completion_function = attempt_shell_completion;
  252.   rl_directory_completion_hook = bash_directory_completion_hook;
  253.   rl_ignore_some_completions_function = (Function *)filename_completion_ignore;
  254. }
  255.  
  256. /* Contains the line to push into readline. */
  257. static char *push_to_readline = (char *)NULL;
  258.  
  259. /* Push the contents of push_to_readline into the
  260.    readline buffer. */
  261. static void
  262. bash_push_line ()
  263. {
  264.   if (push_to_readline)
  265.     {
  266.       rl_insert_text (push_to_readline);
  267.       free (push_to_readline);
  268.       push_to_readline = (char *)NULL;
  269.       rl_startup_hook = old_rl_startup_hook;
  270.     }
  271. }
  272.  
  273. /* Call this to set the initial text for the next line to read
  274.    from readline. */
  275. int
  276. bash_re_edit (line)
  277.      char *line;
  278. {
  279.   if (push_to_readline)
  280.     free (push_to_readline);
  281.  
  282.   push_to_readline = savestring (line);
  283.   old_rl_startup_hook = rl_startup_hook;
  284.   rl_startup_hook = (Function *)bash_push_line;
  285.  
  286.   return (0);
  287. }
  288.  
  289. static void
  290. display_shell_version (count, c)
  291.      int count, c;
  292. {
  293.   crlf ();
  294.   show_shell_version ();
  295.   putc ('\r', rl_outstream);
  296.   fflush (rl_outstream);
  297.   rl_on_new_line ();
  298.   rl_redisplay ();
  299. }
  300.  
  301. /* **************************************************************** */
  302. /*                                    */
  303. /*                 Readline Stuff                */
  304. /*                                    */
  305. /* **************************************************************** */
  306.  
  307. /* If the user requests hostname completion, then simply build a list
  308.    of hosts, and complete from that forever more. */
  309. #if !defined (ETCHOSTS)
  310. #define ETCHOSTS "/etc/hosts"
  311. #endif
  312.  
  313. /* The kept list of hostnames. */
  314. static char **hostname_list = (char **)NULL;
  315.  
  316. /* The physical size of the above list. */
  317. static int hostname_list_size = 0;
  318.  
  319. /* The length of the above list. */
  320. static int hostname_list_length = 0;
  321.  
  322. /* Whether or not HOSTNAME_LIST has been initialized. */
  323. int hostname_list_initialized = 0;
  324.  
  325. /* Non-zero means that HOSTNAME_LIST needs to be sorted. */
  326. static int hostname_list_needs_sorting = 0;
  327.  
  328. /* Initialize the hostname completion table. */
  329. static void
  330. initialize_hostname_list ()
  331. {
  332.   char *temp = get_string_value ("hostname_completion_file");
  333.  
  334.   if (!temp)
  335.     temp = ETCHOSTS;
  336.  
  337.   snarf_hosts_from_file (temp);
  338.   sort_hostname_list ();
  339.   if (hostname_list)
  340.     hostname_list_initialized++;
  341. }
  342.  
  343. /* Add NAME to the list of hosts. */
  344. static void
  345. add_host_name (name)
  346.      char *name;
  347. {
  348.   if (hostname_list_length + 2 > hostname_list_size)
  349.     {
  350.       hostname_list = (char **)
  351.     xrealloc (hostname_list,
  352.           (1 + (hostname_list_size += 100)) * sizeof (char *));
  353.     }
  354.  
  355.   hostname_list[hostname_list_length] = savestring (name);
  356.   hostname_list[++hostname_list_length] = (char *)NULL;
  357.   hostname_list_needs_sorting++;
  358. }
  359.  
  360. /* After you have added some names, you should sort the list of names. */
  361. static void
  362. sort_hostname_list ()
  363. {
  364.   if (hostname_list_needs_sorting && hostname_list)
  365.     sort_char_array (hostname_list);
  366.   hostname_list_needs_sorting = 0;
  367. }
  368.  
  369. #define cr_whitespace(c) ((c) == '\r' || (c) == '\n' || whitespace(c))
  370.  
  371. static void
  372. snarf_hosts_from_file (filename)
  373.      char *filename;
  374. {
  375.   FILE *file = fopen (filename, "r");
  376.   char *temp, buffer[256], name[256];
  377.   register int i, start;
  378.  
  379.   if (!file)
  380.     return;
  381.  
  382.   while (temp = fgets (buffer, 255, file))
  383.     {
  384.       /* Skip to first character. */
  385.       for (i = 0; buffer[i] && cr_whitespace (buffer[i]); i++);
  386.  
  387.       /* If comment, ignore. */
  388.       if (buffer[i] == '#')
  389.     continue;
  390.  
  391.       /* If `preprocessor' directive, do the include. */
  392.       if (strncmp (&buffer[i], "$include ", 9) == 0)
  393.     {
  394.       char *includefile = &buffer[i + 9];
  395.       char *t;
  396.  
  397.       /* Find start of filename. */
  398.       while (*includefile && whitespace (*includefile))
  399.         includefile++;
  400.  
  401.       t = includefile;
  402.  
  403.       /* Find end of filename. */
  404.       while (*t && !cr_whitespace (*t))
  405.         t++;
  406.  
  407.       *t = '\0';
  408.  
  409.       snarf_hosts_from_file (includefile);
  410.       continue;
  411.     }
  412.  
  413.       /* Skip internet address. */
  414.       for (; buffer[i] && !cr_whitespace (buffer[i]); i++);
  415.  
  416.       /* Gobble up names.  Each name is separated with whitespace. */
  417.       while (buffer[i] && buffer[i] != '#')
  418.     {
  419.       for (; i && cr_whitespace (buffer[i]); i++);
  420.       if (buffer[i] ==  '#')
  421.         continue;
  422.       for (start = i; buffer[i] && !cr_whitespace (buffer[i]); i++);
  423.       if ((i - start) == 0)
  424.         continue;
  425.       strncpy (name, buffer + start, i - start);
  426.       name[i - start] = '\0';
  427.       add_host_name (name);
  428.     }
  429.     }
  430.   fclose (file);
  431. }
  432.  
  433. /* Return a NULL terminated list of hostnames which begin with TEXT.
  434.    Initialize the hostname list the first time if neccessary.
  435.    The array is malloc ()'ed, but not the individual strings. */
  436. static char **
  437. hostnames_matching (text)
  438.      char *text;
  439. {
  440.   register int i, len = strlen (text);
  441.   register int begin, end;
  442.   int last_search = -1;
  443.   char **result = (char **)NULL;
  444.  
  445.   if (!hostname_list_initialized)
  446.     {
  447.       initialize_hostname_list ();
  448.  
  449.       if (!hostname_list_initialized)
  450.     return ((char **)NULL);
  451.     }
  452.  
  453.   sort_hostname_list ();
  454.  
  455.   /* The list is sorted.  Do a binary search on it for the first character
  456.      in TEXT, and then grovel the names of interest. */
  457.   begin = 0; end = hostname_list_length;
  458.  
  459.   /* Special case.  If TEXT consists of nothing, then the whole list is
  460.      what is desired. */
  461.   if (!*text)
  462.     {
  463.       result = (char **)xmalloc ((1 + hostname_list_length) * sizeof (char *));
  464.       for (i = 0; i < hostname_list_length; i++)
  465.     result[i] = hostname_list[i];
  466.       result[i] = (char *)NULL;
  467.       return (result);
  468.     }
  469.  
  470.   /* Scan until found, or failure. */
  471.   while (end != begin)
  472.     {
  473.       int r = 0;
  474.  
  475.       i = ((end - begin) / 2) + begin;
  476.       if (i == last_search)
  477.     break;
  478.  
  479.       if (hostname_list[i] &&
  480.       (r = strncmp (hostname_list[i], text, len)) == 0)
  481.     {
  482.       while (strncmp (hostname_list[i], text, len) == 0 && i) i--;
  483.       if (strncmp (hostname_list[i], text, len) != 0) i++;
  484.  
  485.       begin = i;
  486.       while (hostname_list[i] &&
  487.          strncmp (hostname_list[i], text, len) == 0) i++;
  488.       end = i;
  489.  
  490.       result = (char **)xmalloc ((1 + (end - begin)) * sizeof (char *));
  491.       for (i = 0; i + begin < end; i++)
  492.         result[i] = hostname_list[begin + i];
  493.       result[i] = (char *)NULL;
  494.       return (result);
  495.     }
  496.  
  497.       last_search = i;
  498.  
  499.       if (r < 0)
  500.     begin = i;
  501.       else
  502.     end = i;
  503.     }
  504.   return ((char **)NULL);
  505. }
  506.  
  507. /* The equivalent of the K*rn shell C-o operate-and-get-next-history-line
  508.    editing command. */
  509. static int saved_history_line_to_use = 0;
  510.  
  511. static void
  512. set_saved_history ()
  513. {
  514.   if (saved_history_line_to_use)
  515.     rl_get_previous_history (history_length - saved_history_line_to_use);
  516.   saved_history_line_to_use = 0;
  517.   rl_startup_hook = old_rl_startup_hook;
  518. }  
  519.  
  520. static void
  521. operate_and_get_next (count, c)
  522.      int count, c;
  523. {
  524.   int where;
  525.  
  526.   /* Accept the current line. */
  527.   rl_newline ();    
  528.  
  529.   /* Find the current line, and find the next line to use. */
  530.   where = where_history ();
  531.  
  532.   if ((history_is_stifled () && (history_length >= max_input_history)) ||
  533.       (where >= history_length - 1))
  534.     saved_history_line_to_use = where;
  535.   else
  536.     saved_history_line_to_use = where + 1;
  537.  
  538.   old_rl_startup_hook = rl_startup_hook;
  539.   rl_startup_hook = (Function *)set_saved_history;
  540. }
  541.  
  542. #if defined (VI_MODE)
  543. /* This vi mode command causes VI_EDIT_COMMAND to be run on the current
  544.    command being entered (if no explicit argument is given), otherwise on
  545.    a command from the history file. */
  546.  
  547. #define VI_EDIT_COMMAND "fc -e ${VISUAL:-${EDITOR:-vi}}"
  548.  
  549. static void
  550. vi_edit_and_execute_command (count, c)
  551. {
  552.   char *command;
  553.  
  554.   /* Accept the current line. */
  555.   rl_newline ();    
  556.  
  557.   if (rl_explicit_arg)
  558.     {
  559.       command = xmalloc (strlen (VI_EDIT_COMMAND) + 8);
  560.       sprintf (command, "%s %d", VI_EDIT_COMMAND, count);
  561.     }
  562.   else
  563.     {
  564.       /* Take the command we were just editing, add it to the history file,
  565.      then call fc to operate on it.  We have to add a dummy command to
  566.      the end of the history because fc ignores the last command (assumes
  567.      it's supposed to deal with the command before the `fc'). */
  568.       using_history ();
  569.       add_history (rl_line_buffer);
  570.       add_history ("");
  571.       history_lines_this_session++;
  572.       using_history ();
  573.       command = savestring (VI_EDIT_COMMAND);
  574.     }
  575.   parse_and_execute (command, "v", -1);
  576. }
  577. #endif /* VI_MODE */
  578.  
  579. /* **************************************************************** */
  580. /*                                    */
  581. /*            How To Do Shell Completion            */
  582. /*                                    */
  583. /* **************************************************************** */
  584.  
  585. /* Do some completion on TEXT.  The indices of TEXT in RL_LINE_BUFFER are
  586.    at START and END.  Return an array of matches, or NULL if none. */
  587. static char **
  588. attempt_shell_completion (text, start, end)
  589.      char *text;
  590.      int start, end;
  591. {
  592.   int in_command_position, ti;
  593.   char **matches = (char **)NULL;
  594.   char *command_separator_chars = ";|&{(`";
  595.  
  596.   rl_ignore_some_completions_function =
  597.     (Function *)filename_completion_ignore;
  598.  
  599.   /* Determine if this could be a command word.  It is if it appears at
  600.      the start of the line (ignoring preceding whitespace), or if it
  601.      appears after a character that separates commands.  It cannot be a
  602.      command word if we aren't at the top-level prompt. */
  603.   ti = start - 1;
  604.  
  605.   while ((ti > -1) && (whitespace (rl_line_buffer[ti])))
  606.     ti--;
  607.  
  608.   in_command_position = 0;
  609.   if (ti < 0)
  610.     {
  611.       /* Only do command completion at the start of a line when we
  612.          are prompting at the top level. */
  613.       if (current_prompt_string == ps1_prompt)
  614.     in_command_position++;
  615.     }
  616.   else if (member (rl_line_buffer[ti], command_separator_chars))
  617.     {
  618.       register int this_char, prev_char;
  619.  
  620.       in_command_position++;
  621.  
  622.       /* Handle the two character tokens `>&', `<&', and `>|'.
  623.          We are not in a command position after one of these. */
  624.       this_char = rl_line_buffer[ti];
  625.       prev_char = rl_line_buffer[ti - 1];
  626.  
  627.       if ((this_char == '&' && (prev_char == '<' || prev_char == '>')) ||
  628.       (this_char == '|' && prev_char == '>'))
  629.     in_command_position = 0;
  630.       else if (char_is_quoted (rl_line_buffer, ti))
  631.     in_command_position = 0;
  632.     }
  633.   else
  634.     {
  635.       /* This still could be in command position.  It is possible
  636.      that all of the previous words on the line are variable
  637.      assignments. */
  638.     }
  639.  
  640.   /* Special handling for command substitution.  XXX - this should handle
  641.      `$(' as well. */
  642.   if (*text == '`' && unclosed_pair (rl_line_buffer, start, "`"))
  643.     matches = completion_matches (text, command_subst_completion_function);
  644.  
  645.   /* Variable name? */
  646.   if (!matches && *text == '$')
  647.     matches = completion_matches (text, variable_completion_function);
  648.  
  649.   /* If the word starts in `~', and there is no slash in the word, then
  650.      try completing this word as a username. */
  651.   if (!matches && *text == '~' && !strchr (text, '/'))
  652.     matches = completion_matches (text, username_completion_function);
  653.  
  654.   /* Another one.  Why not?  If the word starts in '@', then look through
  655.      the world of known hostnames for completion first. */
  656.   if (!matches && *text == '@')
  657.     matches = completion_matches (text, hostname_completion_function);
  658.  
  659.   /* And last, (but not least) if this word is in a command position, then
  660.      complete over possible command names, including aliases, functions,
  661.      and command names. */
  662.   if (!matches && in_command_position)
  663.     {
  664.       matches = completion_matches (text, command_word_completion_function);
  665.       /* If we are attempting command completion and nothing matches, we
  666.      do not want readline to perform filename completion for us.  We
  667.      still want to be able to complete partial pathnames, so set the
  668.      completion ignore function to something which will remove filenames
  669.      and leave directories in the match list. */
  670.       if (!matches)
  671.     rl_ignore_some_completions_function = (Function *)bash_ignore_filenames;
  672.     }
  673.  
  674.   return (matches);
  675. }
  676.  
  677. /* This is the function to call when the word to complete is in a position
  678.    where a command word can be found.  It grovels $PATH, looking for commands
  679.    that match.  It also scans aliases, function names, and the shell_builtin
  680.    table. */
  681. static char *
  682. command_word_completion_function (hint_text, state)
  683.      char *hint_text;
  684.      int state;
  685. {
  686.   static char *hint = (char *)NULL;
  687.   static char *path = (char *)NULL;
  688.   static char *val = (char *)NULL;
  689.   static char *filename_hint = (char *)NULL;
  690.   static int path_index, hint_len, istate;
  691.   static int mapping_over, local_index;
  692.   static SHELL_VAR **varlist = (SHELL_VAR **)NULL;
  693. #if defined (ALIAS)
  694.   static ASSOC **alias_list = (ASSOC **)NULL;
  695. #endif /* ALIAS */
  696.  
  697.   /* We have to map over the possibilities for command words.  If we have
  698.      no state, then make one just for that purpose. */
  699.  
  700.   if (!state)
  701.     {
  702.       if (hint)
  703.     free (hint);
  704.  
  705.       mapping_over = 0;
  706.       val = (char *)NULL;
  707.  
  708.       /* If this is an absolute program name, do not check it against
  709.      aliases, reserved words, functions or builtins.  We must check
  710.      whether or not it is unique, and, if so, whether that filename
  711.      is executable. */
  712.       if (absolute_program (hint_text))
  713.     {
  714.       /* Perform tilde expansion on what's passed, so we don't end up
  715.          passing filenames with tildes directly to stat(). */
  716.       if (*hint_text == '~')
  717.         hint = tilde_expand (hint_text);
  718.       else
  719.         hint = savestring (hint_text);
  720.       hint_len = strlen (hint);
  721.  
  722.       if (filename_hint)
  723.         free (filename_hint);
  724.       filename_hint = savestring (hint);
  725.  
  726.       mapping_over = 4;
  727.       istate = 0;
  728.       goto inner;
  729.     }
  730.  
  731.       hint = savestring (hint_text);
  732.       hint_len = strlen (hint);
  733.  
  734.       path = get_string_value ("PATH");
  735.       path_index = 0;
  736.  
  737.       /* Initialize the variables for each type of command word. */
  738.       local_index = 0;
  739.  
  740.       if (varlist)
  741.     free (varlist);
  742.  
  743.       varlist = all_visible_functions ();
  744.  
  745. #if defined (ALIAS)
  746.       if (alias_list)
  747.     free (alias_list);
  748.  
  749.       alias_list = all_aliases ();
  750. #endif /* ALIAS */
  751.     }
  752.  
  753.   /* mapping_over says what we are currently hacking.  Note that every case
  754.      in this list must fall through when there are no more possibilities. */
  755.  
  756.   switch (mapping_over)
  757.     {
  758.     case 0:            /* Aliases come first. */
  759. #if defined (ALIAS)
  760.       while (alias_list && alias_list[local_index])
  761.     {
  762.       register char *alias;
  763.  
  764.       alias = alias_list[local_index++]->name;
  765.  
  766.       if (STREQN (alias, hint, hint_len))
  767.         return (savestring (alias));
  768.     }
  769. #endif /* ALIAS */
  770.       local_index = 0;
  771.       mapping_over++;
  772.  
  773.     case 1:            /* Then shell reserved words. */
  774.       {
  775.     while (word_token_alist[local_index].word)
  776.       {
  777.         register char *reserved_word;
  778.  
  779.         reserved_word = word_token_alist[local_index++].word;
  780.  
  781.         if (STREQN (reserved_word, hint, hint_len))
  782.           return (savestring (reserved_word));
  783.       }
  784.     local_index = 0;
  785.     mapping_over++;
  786.       }
  787.  
  788.     case 2:            /* Then function names. */
  789.       while (varlist && varlist[local_index])
  790.     {
  791.       register char *varname;
  792.  
  793.       varname = varlist[local_index++]->name;
  794.  
  795.       if (STREQN (varname, hint, hint_len))
  796.         return (savestring (varname));
  797.     }
  798.       local_index = 0;
  799.       mapping_over++;
  800.  
  801.     case 3:            /* Then shell builtins. */
  802.       for (; local_index < num_shell_builtins; local_index++)
  803.     {
  804.       /* Ignore it if it doesn't have a function pointer or if it
  805.          is not currently enabled. */
  806.       if (!shell_builtins[local_index].function ||
  807.           (shell_builtins[local_index].flags & BUILTIN_ENABLED) == 0)
  808.         continue;
  809.  
  810.       if (STREQN (shell_builtins[local_index].name, hint, hint_len))
  811.         {
  812.           int i = local_index++;
  813.  
  814.           return (savestring (shell_builtins[i].name));
  815.         }
  816.     }
  817.       local_index = 0;
  818.       mapping_over++;
  819.     }
  820.  
  821.   /* Repeatedly call filename_completion_func<tion while we have
  822.      members of PATH left.  Question:  should we stat each file?
  823.      Answer: we call executable_file () on each file. */
  824.  outer:
  825.  
  826.   istate = (val != (char *)NULL);
  827.  
  828.   if (!istate)
  829.     {
  830.       char *current_path;
  831.  
  832.       /* Get the next directory from the path.  If there is none, then we
  833.      are all done. */
  834.       if (!path || !path[path_index] ||
  835.       (current_path = extract_colon_unit (path, &path_index)) == 0)
  836.     return ((char *)NULL);
  837.  
  838.       if (*current_path == 0)
  839.     {
  840.       free (current_path);
  841.       current_path = savestring (".");
  842.     }
  843.  
  844.       if (*current_path == '~')
  845.     {
  846.       char *t;
  847.  
  848.       t = tilde_expand (current_path);
  849.       free (current_path);
  850.       current_path = t;
  851.     }
  852.  
  853.       if (filename_hint)
  854.     free (filename_hint);
  855.  
  856.       filename_hint = xmalloc (2 + strlen (current_path) + hint_len);
  857.       sprintf (filename_hint, "%s/%s", current_path, hint);
  858.  
  859.       free (current_path);
  860.     }
  861.  
  862.  inner:
  863.   val = filename_completion_function (filename_hint, istate);
  864.   istate = 1;
  865.  
  866.   if (!val)
  867.     {
  868.       /* If the hint text is an absolute program, then don't bother
  869.      searching through PATH. */
  870.       if (absolute_program (hint))
  871.     return ((char *)NULL);
  872.  
  873.       goto outer;
  874.     }
  875.   else
  876.     {
  877.       int match;
  878.       char *temp;
  879.  
  880.       if (absolute_program (hint))
  881.     {
  882.       match = strncmp (val, hint, hint_len) == 0;
  883.       /* If we performed tilde expansion, restore the original
  884.          filename. */
  885.       if (*hint_text == '~')
  886.         {
  887.           int l, tl, vl;
  888.           vl = strlen (val);
  889.           tl = strlen (hint_text);
  890.           l = vl - hint_len;    /* # of chars added */
  891.           temp = xmalloc (l + 2 + tl);
  892.           strcpy (temp, hint_text);
  893.           strcpy (temp + tl, val + vl - l);
  894.         }
  895.       else
  896.         temp = savestring (val);
  897.     }
  898.       else
  899.     {
  900.       temp = strrchr (val, '/');
  901.  
  902.       if (temp)
  903.         {
  904.           temp++;
  905.           match = strncmp (temp, hint, hint_len) == 0;
  906.           if (match)
  907.         temp = savestring (temp);
  908.         }
  909.       else
  910.         match = 0;
  911.     }
  912.  
  913.       /* If we have found a match, and it is an executable file, return it. */
  914.       if (match && executable_file (val))
  915.     {
  916.       free (val);
  917.       val = "";        /* So it won't be NULL. */
  918.       return (temp);
  919.     }
  920.       else
  921.     {
  922.       free (val);
  923.       goto inner;
  924.     }
  925.     }
  926. }
  927.  
  928. static char *
  929. command_subst_completion_function (text, state)
  930.      int state;
  931.      char *text;
  932. {
  933.   char **matches = (char **)NULL;
  934.   static char *orig_start, *filename_text = (char *)NULL;
  935.   static int cmd_index, start_len;
  936.  
  937.   if (state == 0)
  938.     {
  939.       if (filename_text)
  940.     free (filename_text);
  941.       orig_start = text;
  942.       if (*text == '`')
  943.         text++;
  944.       else if (*text == '$' && text[1] == '(')
  945.         text += 2;
  946.       start_len = text - orig_start;
  947.       filename_text = savestring (text);
  948.       if (matches)
  949.     free (matches);
  950.       matches = completion_matches (filename_text, command_word_completion_function);
  951.       cmd_index = 0;
  952.     }
  953.  
  954.   if (!matches || !matches[cmd_index])
  955.     {
  956.       rl_filename_quoting_desired = 0;    /* disable quoting */
  957.       return ((char *)NULL);
  958.     }
  959.   else
  960.     {
  961.       char *value;
  962.  
  963.       value = xmalloc (1 + start_len + strlen (matches[cmd_index]));
  964.  
  965.       if (start_len == 1)
  966.         value[0] = *orig_start;
  967.       else
  968.         strncpy (value, orig_start, start_len);
  969.  
  970.       strcpy (value + start_len, matches[cmd_index]);
  971.  
  972.       cmd_index++;
  973.       return (value);
  974.     }
  975. }
  976.  
  977. /* Okay, now we write the entry_function for variable completion. */
  978. static char *
  979. variable_completion_function (text, state)
  980.      int state;
  981.      char *text;
  982. {
  983.   register SHELL_VAR *var = (SHELL_VAR *)NULL;
  984.   static SHELL_VAR **varlist = (SHELL_VAR **)NULL;
  985.   static int varlist_index;
  986.   static char *varname = (char *)NULL;
  987.   static int namelen;
  988.   static int first_char, first_char_loc;
  989.  
  990.   if (!state)
  991.     {
  992.       if (varname)
  993.     free (varname);
  994.  
  995.       first_char_loc = 0;
  996.       first_char = text[0];
  997.  
  998.       if (first_char == '$')
  999.     first_char_loc++;
  1000.  
  1001.       varname = savestring (text + first_char_loc);
  1002.  
  1003.       namelen = strlen (varname);
  1004.       if (varlist)
  1005.     free (varlist);
  1006.       varlist = all_visible_variables ();
  1007.       varlist_index = 0;
  1008.     }
  1009.  
  1010.   while (varlist && varlist[varlist_index])
  1011.     {
  1012.       var = varlist[varlist_index];
  1013.  
  1014.       /* Compare.  You can't do better than Zayre.  No text is also
  1015.      a match.  */
  1016.       if (!*varname || (strncmp (varname, var->name, namelen) == 0))
  1017.     break;
  1018.       varlist_index++;
  1019.     }
  1020.  
  1021.   if (!varlist || !varlist[varlist_index])
  1022.     {
  1023.       return ((char *)NULL);
  1024.     }
  1025.   else
  1026.     {
  1027.       char *value = xmalloc (2 + strlen (var->name));
  1028.  
  1029.       if (first_char_loc)
  1030.     *value = first_char;
  1031.  
  1032.       strcpy (&value[first_char_loc], var->name);
  1033.  
  1034.       varlist_index++;
  1035.       return (value);
  1036.     }
  1037. }
  1038.  
  1039. /* How about a completion function for hostnames? */
  1040. static char *
  1041. hostname_completion_function (text, state)
  1042.      int state;
  1043.      char *text;
  1044. {
  1045.   static char **list = (char **)NULL;
  1046.   static int list_index = 0;
  1047.   static int first_char, first_char_loc;
  1048.  
  1049.   /* If we don't have any state, make some. */
  1050.   if (!state)
  1051.     {
  1052.       if (list)
  1053.     free (list);
  1054.  
  1055.       list = (char **)NULL;
  1056.  
  1057.       first_char_loc = 0;
  1058.       first_char = *text;
  1059.  
  1060.       if (first_char == '@')
  1061.     first_char_loc++;
  1062.  
  1063.       list = hostnames_matching (&text[first_char_loc]);
  1064.       list_index = 0;
  1065.     }
  1066.  
  1067.   if (list && list[list_index])
  1068.     {
  1069.       char *t = xmalloc (2 + strlen (list[list_index]));
  1070.  
  1071.       *t = first_char;
  1072.       strcpy (t + first_char_loc, list[list_index]);
  1073.       list_index++;
  1074.       return (t);
  1075.     }
  1076.   else
  1077.     return ((char *)NULL);
  1078. }
  1079.  
  1080. /* History and alias expand the line. */
  1081. static char *
  1082. history_expand_line_internal (line)
  1083.      char *line;
  1084. {
  1085.   char *new_line;
  1086.  
  1087.   new_line = pre_process_line (line, 0, 0);
  1088.   return new_line;
  1089. }
  1090.  
  1091. #if defined (ALIAS)
  1092. /* Perform alias expansion on LINE and return the new line. */
  1093. static char *
  1094. alias_expand_line_internal (line)
  1095.      char *line;
  1096. {
  1097.   char *alias_line;
  1098.  
  1099.   alias_line = alias_expand (line);
  1100.   return alias_line;
  1101. }
  1102. #endif
  1103.  
  1104. /* There was an error in expansion.  Let the preprocessor print
  1105.    the error here. */
  1106. static void
  1107. cleanup_expansion_error ()
  1108. {
  1109.   char *to_free;
  1110.  
  1111.   fprintf (rl_outstream, "\r\n");
  1112.   to_free = pre_process_line (rl_line_buffer, 1, 0);
  1113.   free (to_free);
  1114.   putc ('\r', rl_outstream);
  1115.   rl_forced_update_display ();
  1116. }
  1117.  
  1118. /* If NEW_LINE differs from what is in the readline line buffer, add an
  1119.    undo record to get from the readline line buffer contents to the new
  1120.    line and make NEW_LINE the current readline line. */
  1121. static void
  1122. maybe_make_readline_line (new_line)
  1123.      char *new_line;
  1124. {
  1125.   if (strcmp (new_line, rl_line_buffer) != 0)
  1126.     {
  1127.       rl_point = rl_end;
  1128.  
  1129.       rl_add_undo (UNDO_BEGIN, 0, 0, 0);
  1130.       rl_delete_text (0, rl_point);
  1131.       rl_point = rl_end = 0;
  1132.       rl_insert_text (new_line);
  1133.       rl_add_undo (UNDO_END, 0, 0, 0);
  1134.     }
  1135. }
  1136.  
  1137. /* Make NEW_LINE be the current readline line.  This frees NEW_LINE. */
  1138. static void
  1139. set_up_new_line (new_line)
  1140.      char *new_line;
  1141. {
  1142.   int old_point = rl_point;
  1143.   int at_end = rl_point == rl_end;
  1144.  
  1145.   /* If the line was history and alias expanded, then make that
  1146.      be one thing to undo. */
  1147.   maybe_make_readline_line (new_line);
  1148.   free (new_line);
  1149.  
  1150.   /* Place rl_point where we think it should go. */
  1151.   if (at_end)
  1152.     rl_point = rl_end;
  1153.   else if (old_point < rl_end)
  1154.     {
  1155.       rl_point = old_point;
  1156.       if (!whitespace (rl_line_buffer[rl_point]))
  1157.     rl_forward_word (1);
  1158.     }
  1159. }
  1160.  
  1161. /* History expand the line. */
  1162. static void
  1163. history_expand_line (ignore)
  1164.      int ignore;
  1165. {
  1166.   char *new_line;
  1167.  
  1168.   new_line = history_expand_line_internal (rl_line_buffer);
  1169.  
  1170.   if (new_line)
  1171.     set_up_new_line (new_line);
  1172.   else
  1173.     cleanup_expansion_error ();
  1174. }
  1175.   
  1176. /* History and alias expand the line. */
  1177. static void
  1178. history_and_alias_expand_line (ignore)
  1179.      int ignore;
  1180. {
  1181.   char *new_line;
  1182.  
  1183.   new_line = pre_process_line (rl_line_buffer, 0, 0);
  1184.  
  1185. #if defined (ALIAS)
  1186.   if (new_line)
  1187.     {
  1188.       char *alias_line;
  1189.  
  1190.       alias_line = alias_expand (new_line);
  1191.       free (new_line);
  1192.       new_line = alias_line;
  1193.     }
  1194. #endif /* ALIAS */
  1195.  
  1196.   if (new_line)
  1197.     set_up_new_line (new_line);
  1198.   else
  1199.     cleanup_expansion_error ();
  1200. }
  1201.  
  1202. /* History and alias expand the line, then perform the shell word
  1203.    expansions by calling expand_string. */
  1204. static void
  1205. shell_expand_line (ignore)
  1206.      int ignore;
  1207. {
  1208.   char *new_line;
  1209.  
  1210.   new_line = pre_process_line (rl_line_buffer, 0, 0);
  1211.  
  1212. #if defined (ALIAS)
  1213.   if (new_line)
  1214.     {
  1215.       char *alias_line;
  1216.  
  1217.       alias_line = alias_expand (new_line);
  1218.       free (new_line);
  1219.       new_line = alias_line;
  1220.     }
  1221. #endif /* ALIAS */
  1222.  
  1223.   if (new_line)
  1224.     {
  1225.       int old_point = rl_point;
  1226.       int at_end = rl_point == rl_end;
  1227.  
  1228.       /* If the line was history and alias expanded, then make that
  1229.      be one thing to undo. */
  1230.       maybe_make_readline_line (new_line);
  1231.       free (new_line);
  1232.  
  1233.       /* If there is variable expansion to perform, do that as a separate
  1234.      operation to be undone. */
  1235.       {
  1236.     WORD_LIST *expanded_string;
  1237.  
  1238.     expanded_string = expand_string (rl_line_buffer, 0);
  1239.     if (!expanded_string)
  1240.       new_line = savestring ("");
  1241.     else
  1242.       {
  1243.         new_line = string_list (expanded_string);
  1244.         dispose_words (expanded_string);
  1245.       }
  1246.  
  1247.     maybe_make_readline_line (new_line);
  1248.     free (new_line);
  1249.  
  1250.     /* Place rl_point where we think it should go. */
  1251.     if (at_end)
  1252.       rl_point = rl_end;
  1253.     else if (old_point < rl_end)
  1254.       {
  1255.         rl_point = old_point;
  1256.         if (!whitespace (rl_line_buffer[rl_point]))
  1257.           rl_forward_word (1);
  1258.       }
  1259.       }
  1260.     }
  1261.   else
  1262.     cleanup_expansion_error ();
  1263. }
  1264.  
  1265. /* Filename completion ignore.  Emulates the "fignore" facility of
  1266.    tcsh.  If FIGNORE is set, then don't match files with the
  1267.    given suffixes.  If only one of the possibilities has an acceptable
  1268.    suffix, delete the others, else just return and let the completer
  1269.    signal an error.  It is called by the completer when real
  1270.    completions are done on filenames by the completer's internal
  1271.    function, not for completion lists (M-?) and not on "other"
  1272.    completion types, such as hostnames or commands.
  1273.  
  1274.    It is passed a NULL-terminated array of (char *)'s that must be
  1275.    free()'d if they are deleted.  The first element (names[0]) is the
  1276.    least-common-denominator string of the matching patterns (i.e.
  1277.    u<TAB> produces names[0] = "und", names[1] = "under.c", names[2] =
  1278.    "undun.c", name[3] = NULL).  */
  1279.  
  1280. struct ign {
  1281.   char *val;
  1282.   int len;
  1283. };
  1284.  
  1285. static struct ign *ignores;    /* Store the ignore strings here */
  1286. static int num_ignores;        /* How many are there? */
  1287. static char *last_fignore;    /* Last value of fignore - cached for speed */
  1288.  
  1289. static void
  1290. setup_ignore_patterns ()
  1291. {
  1292.   int numitems, maxitems, ptr;
  1293.   char *colon_bit;
  1294.   struct ign *p;
  1295.   
  1296.   char *this_fignore = get_string_value ("FIGNORE");
  1297.  
  1298.   /* If nothing has changed then just exit now. */
  1299.   if ((this_fignore &&
  1300.        last_fignore &&
  1301.        strcmp (this_fignore, last_fignore) == 0) ||
  1302.       (!this_fignore && !last_fignore))
  1303.     {
  1304.       return;
  1305.     }
  1306.  
  1307.   /* Oops.  FIGNORE has changed.  Re-parse it. */
  1308.   num_ignores = 0;
  1309.  
  1310.   if (ignores)
  1311.     {
  1312.       for (p = ignores; p->val; p++) free(p->val);
  1313.       free (ignores);
  1314.       ignores = (struct ign*)NULL;
  1315.     }
  1316.  
  1317.   if (last_fignore)
  1318.     {
  1319.       free (last_fignore);
  1320.       last_fignore = (char *)NULL;
  1321.     }
  1322.  
  1323.   if (!this_fignore || !*this_fignore)
  1324.     return;
  1325.  
  1326.   last_fignore = savestring (this_fignore);
  1327.  
  1328.   numitems = maxitems = ptr = 0;
  1329.  
  1330.   while (colon_bit = extract_colon_unit (this_fignore, &ptr))
  1331.     {
  1332.       if (numitems + 1 > maxitems)
  1333.     ignores = (struct ign *)
  1334.       xrealloc (ignores, (maxitems += 10) * sizeof (struct ign));
  1335.  
  1336.       ignores[numitems].val = colon_bit;
  1337.       ignores[numitems].len = strlen (colon_bit);
  1338.       numitems++;
  1339.     }
  1340.   ignores[numitems].val = NULL;
  1341.   num_ignores = numitems;
  1342. }
  1343.  
  1344. static int
  1345. name_is_acceptable (name)
  1346.      char *name;
  1347. {
  1348.   struct ign *p;
  1349.   int nlen = strlen (name);
  1350.  
  1351.   for (p = ignores; p->val; p++) 
  1352.     {
  1353.       if (nlen > p->len && p->len > 0 && 
  1354.       strcmp (p->val, &name[nlen - p->len]) == 0)
  1355.     return (0);
  1356.     }
  1357.  
  1358.   return (1);
  1359. }
  1360.  
  1361. /* Internal function to test whether filenames in NAMES should be
  1362.    ignored.  NAME_FUNC is a pointer to a function to call with each
  1363.    name.  It returns non-zero if the name is acceptable to the particular
  1364.    ignore function which called _ignore_names; zero if the name should
  1365.    be removed from NAMES. */
  1366. static void
  1367. _ignore_names (names, name_func)
  1368.      char **names;
  1369.      Function *name_func;
  1370. {
  1371.   char **p;
  1372.   int idx;
  1373.  
  1374.   for (p = names + 1, idx = -1; *p; p++)
  1375.     {
  1376.       if ((*name_func) (*p))
  1377.     {
  1378.       if (idx == -1)    /* First match found. */
  1379.         idx = p - names;
  1380.       else
  1381.         return;        /* Too many matches. */
  1382.     }
  1383.     }
  1384.   
  1385.   /* If none are acceptable then let the completer handle it. */
  1386.   if (idx == -1)
  1387.     return;
  1388.  
  1389.   /* Delete all non-matching elements. */
  1390.   free (names[0]); 
  1391.   for (p = names + 1; *p; p++)
  1392.     {
  1393.       if (idx == (p - names))
  1394.     names[0] = *p;
  1395.       else 
  1396.     free (*p);
  1397.  
  1398.       *p = NULL;
  1399.     }
  1400. }
  1401.  
  1402. static void
  1403. filename_completion_ignore (names)
  1404.      char **names;
  1405. {
  1406.   setup_ignore_patterns ();
  1407.  
  1408.   if (num_ignores == 0)
  1409.     return;
  1410.  
  1411.   _ignore_names (names, name_is_acceptable);
  1412. }
  1413.  
  1414. /* Return 1 if NAME is a directory. */
  1415. static int
  1416. test_for_directory (name)
  1417.      char *name;
  1418. {
  1419.   struct stat finfo;
  1420.   char *fn;
  1421.  
  1422.   fn = tilde_expand (name);
  1423.   if (stat (fn, &finfo) != 0)
  1424.     {
  1425.       free (fn);
  1426.       return 0;
  1427.     }
  1428.   free (fn);
  1429.   return (S_ISDIR (finfo.st_mode));
  1430. }
  1431.  
  1432. /* Remove files from NAMES, leaving directories. */
  1433. static void
  1434. bash_ignore_filenames (names)
  1435.      char **names;
  1436. {
  1437.   _ignore_names (names, test_for_directory);
  1438. }
  1439.  
  1440. /* Handle symbolic link references and other directory name
  1441.    expansions while hacking completion. */
  1442. static int
  1443. bash_directory_completion_hook (dirname)
  1444.      char **dirname;
  1445. {
  1446.   char *local_dirname, *t;
  1447.   int return_value = 0;
  1448.   WORD_LIST *wl;
  1449.  
  1450.   local_dirname = *dirname;
  1451.   if (strchr (local_dirname, '$') || strchr (local_dirname, '`'))
  1452.     {
  1453.       wl = expand_string (local_dirname, 0);
  1454.       if (wl)
  1455.     {
  1456.       *dirname = string_list (wl);
  1457.       /* Tell the completer to replace the directory name only if we
  1458.          actually expanded something. */
  1459.       return_value = STREQ (local_dirname, *dirname) == 0;
  1460.       free (local_dirname);
  1461.       dispose_words (wl);
  1462.       local_dirname = *dirname;
  1463.     }
  1464.       else
  1465.     {
  1466.       free (local_dirname);
  1467.       *dirname = savestring ("");
  1468.       return 1;
  1469.     }
  1470.     }
  1471.  
  1472.   if (!no_symbolic_links && (local_dirname[0] != '.' || local_dirname[1]))
  1473.     {
  1474.       char *temp1, *temp2;
  1475.       int len1, len2;
  1476.  
  1477.       t = get_working_directory ("symlink-hook");
  1478.       temp1 = make_absolute (local_dirname, t);
  1479.       free (t);
  1480.       temp2 = canonicalize_pathname (temp1);
  1481.       len1 = strlen (temp1);
  1482.       if (temp1[len1 - 1] == '/')
  1483.         {
  1484.       len2 = strlen (temp2);
  1485.           temp2 = xrealloc (temp2, len2 + 2);
  1486.           temp2[len2] = '/';
  1487.           temp2[len2 + 1] = '\0';
  1488.         }
  1489.       free (local_dirname);
  1490.       *dirname = temp2;
  1491.       free (temp1);
  1492.     }
  1493.   return (return_value);
  1494. }
  1495.  
  1496. #if defined (DYNAMIC_HISTORY_COMPLETION)
  1497. static char **history_completion_array = (char **)NULL;
  1498. static int harry_size = 0;
  1499. static int harry_len = 0;
  1500.  
  1501. static void
  1502. build_history_completion_array ()
  1503. {
  1504.   register int i;
  1505.  
  1506.   /* First, clear out the current dynamic history completion list. */
  1507.   if (harry_size)
  1508.     {
  1509.       for (i = 0; history_completion_array[i]; i++)
  1510.     free (history_completion_array[i]);
  1511.  
  1512.       free (history_completion_array);
  1513.  
  1514.       history_completion_array = (char **)NULL;
  1515.       harry_size = 0;
  1516.       harry_len = 0;
  1517.     }
  1518.  
  1519.   /* Next, grovel each line of history, making each shell-sized token
  1520.      a separate entry in the history_completion_array. */
  1521.   {
  1522.     HIST_ENTRY **hlist;
  1523.  
  1524.     hlist = history_list ();
  1525.  
  1526.     if (hlist)
  1527.       {
  1528.     register int j;
  1529.  
  1530.     for (i = 0; hlist[i]; i++)
  1531.       {
  1532.         char **tokens;
  1533.  
  1534.         /* Separate each token, and place into an array. */
  1535.         tokens = history_tokenize (hlist[i]->line);
  1536.  
  1537.         for (j = 0; tokens && tokens[j]; j++)
  1538.           {
  1539.         if (harry_len + 2 > harry_size)
  1540.           history_completion_array = (char **) xrealloc
  1541.             (history_completion_array,
  1542.              (harry_size += 10) * sizeof (char *));
  1543.  
  1544.         history_completion_array[harry_len++] = tokens[j];
  1545.         history_completion_array[harry_len] = (char *)NULL;
  1546.           }
  1547.         free (tokens);
  1548.       }
  1549.  
  1550.     /* Sort the complete list of tokens. */
  1551.     qsort (history_completion_array, harry_len, sizeof (char *),
  1552.            (Function *)qsort_string_compare);
  1553.  
  1554.     /* Instead of removing the duplicate entries here, we let the
  1555.        code in the completer handle it. */
  1556.       }
  1557.   }
  1558. }
  1559.  
  1560. static char *
  1561. history_completion_generator (hint_text, state)
  1562.      char *hint_text;
  1563.      int state;
  1564. {
  1565.   static int local_index = 0;
  1566.   static char *text = (char *)NULL;
  1567.   static int len = 0;
  1568.  
  1569.   /* If this is the first call to the generator, then initialize the
  1570.      list of strings to complete over. */
  1571.   if (!state)
  1572.     {
  1573.       local_index = 0;
  1574.       build_history_completion_array ();
  1575.       text = hint_text;
  1576.       len = strlen (text);
  1577.     }
  1578.  
  1579.   while (history_completion_array && history_completion_array[local_index])
  1580.     {
  1581.       if (strncmp (text, history_completion_array[local_index++], len) == 0)
  1582.     return (savestring (history_completion_array[local_index - 1]));
  1583.     }
  1584.   return ((char *)NULL);
  1585. }
  1586.  
  1587. static void
  1588. dynamic_complete_history (count, key)
  1589.      int count, key;
  1590. {
  1591.   Function *orig_func;
  1592.   CPPFunction *orig_attempt_func;
  1593.  
  1594.   orig_func = rl_completion_entry_function;
  1595.   orig_attempt_func = rl_attempted_completion_function;
  1596.   rl_completion_entry_function = (Function *)history_completion_generator;
  1597.   rl_attempted_completion_function = (CPPFunction *)NULL;
  1598.  
  1599.   if (rl_last_func == (Function *)dynamic_complete_history)
  1600.     rl_complete_internal ('?');
  1601.   else
  1602.     rl_complete_internal (TAB);
  1603.  
  1604.   rl_completion_entry_function = orig_func;
  1605.   rl_attempted_completion_function = orig_attempt_func;
  1606. }
  1607.  
  1608. #endif /* DYNAMIC_HISTORY_COMPLETION */
  1609.  
  1610. #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
  1611. static void
  1612. bash_complete_username (ignore, ignore2)
  1613.      int ignore, ignore2;
  1614. {
  1615.   bash_complete_username_internal (TAB);
  1616. }
  1617.  
  1618. static void
  1619. bash_possible_username_completions (ignore, ignore2)
  1620.      int ignore, ignore2;
  1621. {
  1622.   bash_complete_username_internal ('?');
  1623. }
  1624.  
  1625. static void
  1626. bash_complete_username_internal (what_to_do)
  1627.      int what_to_do;
  1628. {
  1629.   bash_specific_completion
  1630.     (what_to_do, (Function *)username_completion_function);
  1631. }
  1632.  
  1633. static void
  1634. bash_complete_filename (ignore, ignore2)
  1635.      int ignore, ignore2;
  1636. {
  1637.   bash_complete_filename_internal (TAB);
  1638. }
  1639.  
  1640. static void
  1641. bash_possible_filename_completions (ignore, ignore2)
  1642.      int ignore, ignore2;
  1643. {
  1644.   bash_complete_filename_internal ('?');
  1645. }
  1646.  
  1647. static void
  1648. bash_complete_filename_internal (what_to_do)
  1649.      int what_to_do;
  1650. {
  1651.   Function  *orig_func, *orig_dir_func;
  1652.   CPPFunction *orig_attempt_func;
  1653.   char *orig_rl_completer_word_break_characters;
  1654.  
  1655.   orig_func = rl_completion_entry_function;
  1656.   orig_attempt_func = rl_attempted_completion_function;
  1657.   orig_dir_func = rl_directory_completion_hook;
  1658.   orig_rl_completer_word_break_characters = rl_completer_word_break_characters;
  1659.   rl_completion_entry_function = (Function *)filename_completion_function;
  1660.   rl_attempted_completion_function = (CPPFunction *)NULL;
  1661.   rl_directory_completion_hook = (Function *)NULL;
  1662.   rl_completer_word_break_characters = " \t\n\"\'";
  1663.  
  1664.   rl_complete_internal (what_to_do);
  1665.  
  1666.   rl_completion_entry_function = orig_func;
  1667.   rl_attempted_completion_function = orig_attempt_func;
  1668.   rl_directory_completion_hook = orig_dir_func;
  1669.   rl_completer_word_break_characters = orig_rl_completer_word_break_characters;
  1670. }
  1671.  
  1672. static void
  1673. bash_complete_hostname (ignore, ignore2)
  1674.      int ignore, ignore2;
  1675. {
  1676.   bash_complete_hostname_internal (TAB);
  1677. }
  1678.  
  1679. static void
  1680. bash_possible_hostname_completions (ignore, ignore2)
  1681.      int ignore, ignore2;
  1682. {
  1683.   bash_complete_hostname_internal ('?');
  1684. }
  1685.  
  1686. static void
  1687. bash_complete_variable (ignore, ignore2)
  1688.      int ignore, ignore2;
  1689. {
  1690.   bash_complete_variable_internal (TAB);
  1691. }
  1692.  
  1693. static void
  1694. bash_possible_variable_completions (ignore, ignore2)
  1695.      int ignore, ignore2;
  1696. {
  1697.   bash_complete_variable_internal ('?');
  1698. }
  1699.  
  1700. static void
  1701. bash_complete_command (ignore, ignore2)
  1702.      int ignore, ignore2;
  1703. {
  1704.   bash_complete_command_internal (TAB);
  1705. }
  1706.  
  1707. static void
  1708. bash_possible_command_completions (ignore, ignore2)
  1709.      int ignore, ignore2;
  1710. {
  1711.   bash_complete_command_internal ('?');
  1712. }
  1713.  
  1714. static void
  1715. bash_complete_hostname_internal (what_to_do)
  1716.      int what_to_do;
  1717. {
  1718.   bash_specific_completion
  1719.     (what_to_do, (Function *)hostname_completion_function);
  1720. }
  1721.  
  1722. static void
  1723. bash_complete_variable_internal (what_to_do)
  1724.      int what_to_do;
  1725. {
  1726.   bash_specific_completion
  1727.     (what_to_do, (Function *)variable_completion_function);
  1728. }
  1729.  
  1730. static void
  1731. bash_complete_command_internal (what_to_do)
  1732.      int what_to_do;
  1733. {
  1734.   bash_specific_completion
  1735.     (what_to_do, (Function *)command_word_completion_function);
  1736. }
  1737.  
  1738. static void
  1739. bash_specific_completion (what_to_do, generator)
  1740.      int what_to_do;
  1741.      Function *generator;
  1742. {
  1743.   Function *orig_func;
  1744.   CPPFunction *orig_attempt_func;
  1745.  
  1746.   orig_func = rl_completion_entry_function;
  1747.   orig_attempt_func = rl_attempted_completion_function;
  1748.   rl_completion_entry_function = generator;
  1749.   rl_attempted_completion_function = (CPPFunction *)NULL;
  1750.  
  1751.   rl_complete_internal (what_to_do);
  1752.  
  1753.   rl_completion_entry_function = orig_func;
  1754.   rl_attempted_completion_function = orig_attempt_func;
  1755. }
  1756.  
  1757. #endif    /* SPECIFIC_COMPLETION_FUNCTIONS */
  1758.